package com.estore.service;

import com.estore.model.Product;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 商品服务类，负责商品相关的业务逻辑
 * 目前使用内存Map模拟数据库
 */
public class ProductService {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    // 优点：通过ID查找商品时，时间复杂度是O(1)，非常高效
    private final Map<String, Product> productData = new HashMap<>();

    /**
     * 构造函数，初始化一些商品数据
     */
    public ProductService() {
        productData.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100));
        productData.put("p002", new Product("p002", "高性能MySQL", 128.5, 50));
        productData.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200));
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 0)); // 库存为0的商品
    }

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product> getAllProducts() {
        // 从Map的值集合创建一个新的ArrayList并返回
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product findProductById(String id) {
        return productData.get(id);
    }

    /**
     * 添加新商品
     * @param product 商品对象
     * @return 添加成功返回true，如果商品ID已存在则返回false
     */
    public boolean addProduct(Product product) {
        if (product == null || product.getId() == null || productData.containsKey(product.getId())) {
            return false;
        }
        productData.put(product.getId(), product);
        return true;
    }

    /**
     * 更新商品信息
     * @param product 商品对象
     * @return 更新成功返回true，如果商品不存在则返回false
     */
    public boolean updateProduct(Product product) {
        if (product == null || product.getId() == null || !productData.containsKey(product.getId())) {
            return false;
        }
        productData.put(product.getId(), product);
        return true;
    }

    /**
     * 删除商品
     * @param id 商品ID
     * @return 删除成功返回true，如果商品不存在则返回false
     */
    public boolean deleteProduct(String id) {
        if (id == null || !productData.containsKey(id)) {
            return false;
        }
        productData.remove(id);
        return true;
    }

    /**
     * 根据商品名称模糊搜索商品
     * @param name 商品名称关键词
     * @return 匹配的商品列表
     */
    public List<Product> searchProductsByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return new ArrayList<>();
        }

        String searchKey = name.toLowerCase();
        return productData.values().stream()
                .filter(product -> product.getName().toLowerCase().contains(searchKey))
                .collect(Collectors.toList());
    }

    /**
     * 获取有库存的商品列表
     * @return 库存大于0的商品列表
     */
    public List<Product> getAvailableProducts() {
        return productData.values().stream()
                .filter(product -> product.getStock() > 0)
                .collect(Collectors.toList());
    }

    /**
     * 获取缺货商品列表
     * @return 库存为0的商品列表
     */
    public List<Product> getOutOfStockProducts() {
        return productData.values().stream()
                .filter(product -> product.getStock() == 0)
                .collect(Collectors.toList());
    }

    /**
     * 根据价格范围筛选商品
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 价格在指定范围内的商品列表
     */
    public List<Product> getProductsByPriceRange(double minPrice, double maxPrice) {
        if (minPrice < 0 || maxPrice < minPrice) {
            return new ArrayList<>();
        }

        return productData.values().stream()
                .filter(product -> product.getPrice() >= minPrice && product.getPrice() <= maxPrice)
                .collect(Collectors.toList());
    }

    /**
     * 更新商品库存
     * @param id 商品ID
     * @param newStock 新的库存数量
     * @return 更新成功返回true，如果商品不存在或库存为负数则返回false
     */
    public boolean updateProductStock(String id, int newStock) {
        if (newStock < 0) {
            return false;
        }

        Product product = findProductById(id);
        if (product == null) {
            return false;
        }

        product.setStock(newStock);
        return true;
    }

    /**
     * 减少商品库存（用于下单时）
     * @param id 商品ID
     * @param quantity 减少的数量
     * @return 操作成功返回true，库存不足或商品不存在返回false
     */
    public boolean decreaseProductStock(String id, int quantity) {
        if (quantity <= 0) {
            return false;
        }

        Product product = findProductById(id);
        if (product == null || product.getStock() < quantity) {
            return false;
        }

        product.setStock(product.getStock() - quantity);
        return true;
    }

    /**
     * 增加商品库存（用于补货等场景）
     * @param id 商品ID
     * @param quantity 增加的数量
     * @return 操作成功返回true，商品不存在返回false
     */
    public boolean increaseProductStock(String id, int quantity) {
        if (quantity <= 0) {
            return false;
        }

        Product product = findProductById(id);
        if (product == null) {
            return false;
        }

        product.setStock(product.getStock() + quantity);
        return true;
    }

    /**
     * 获取商品总数
     * @return 商品总数
     */
    public int getTotalProductCount() {
        return productData.size();
    }

    /**
     */
    public boolean productExists(String id) {
        return productData.containsKey(id);
    }

    /**
     * 检查商品是否有足够库存
     */
    public boolean isStockSufficient(String id, int requiredQuantity) {
        Product product = findProductById(id);
        return product != null && product.getStock() >= requiredQuantity;
    }

    /**
     * 获取所有商品的总价值（价格总和）
     */
    public double getTotalProductsValue() {
        return productData.values().stream()
                .mapToDouble(product -> product.getPrice() * product.getStock())
                .sum();
    }
}